Bad block management for memory sub-systems

ABSTRACT

A processing device in a memory system performs operations comprising determining a first pool of data blocks of the memory device, wherein data blocks of the first pool are associated with storing data at a first number of bits per memory cell; determining a second pool of data blocks of the memory device, wherein data blocks of the second pool are associated with storing data at a second number of bits per memory cell that is larger than the first number of bits per memory cell; detecting a failure associated with a particular data block of the second pool of data blocks; and in response to detecting the failure associated with the particular data block, removing the particular data block from the second pool of data blocks and adding the particular data block to the first pool of data blocks.

RELATED APPLICATION

The present Application is a divisional application of U.S. patentapplication Ser. No. 16/228,387, filed on Dec. 20, 2018, which isincorporated by reference herein in its entirety.

TECHNICAL FIELD

Embodiments of the disclosure relate generally to memory sub-systems,and more specifically, relate to managing bad blocks for a memorysub-system.

BACKGROUND

A memory sub-system can be a storage system, such as a solid-state drive(SSD), or a hard disk drive (HDD). A memory sub-system can be a memorymodule, such as a dual in-line memory module (DIMM), a small outlineDIMM (SO-DIMM), or a non-volatile dual in-line memory module (NVDIMM). Amemory sub-system can include one or more memory components that storedata. The memory components can be, for example, non-volatile memorycomponents and volatile memory components. In general, a host system canutilize a memory sub-system to store data at the memory components andto retrieve data from the memory components.

BRIEF DESCRIPTION OF THE DRAWINGS

The present disclosure will be understood more fully from the detaileddescription given below and from the accompanying drawings of variousembodiments of the disclosure.

FIG. 1 illustrates an example computing environment that includes amemory sub-system in accordance with some embodiments of the presentdisclosure.

FIG. 2A illustrates an example of determining whether to store data at abad data block in accordance with some embodiments of the presentdisclosure.

FIG. 2B illustrates an example of updating a pool of bad data blocks inaccordance with some embodiments of the present disclosure.

FIG. 3 is a flow diagram of an example method to store data at a baddata block of a memory sub-system based on a type of data in accordancewith some embodiments of the present disclosure.

FIG. 4 is a flow diagram of an example method to manage a pool of baddata blocks of a memory sub-system in accordance with some embodimentsof the present disclosure.

FIG. 5 is a block diagram of an example computer system in whichembodiments of the present disclosure may operate.

DETAILED DESCRIPTION

Aspects of the present disclosure are directed managing bad blocks for amemory sub-system. A memory sub-system is also hereinafter referred toas a “memory device.” An example of a memory sub-system is a storagedevice that is coupled to a central processing unit (CPU) via aperipheral interconnect (e.g., an input/output bus, a storage areanetwork). Examples of storage devices include a solid-state drive (SSD),a flash drive, a universal serial bus (USB) flash drive, and a hard diskdrive (HDD). Another example of a memory sub-system is a memory modulethat is coupled to the CPU via a memory bus. Examples of memory modulesinclude a dual in-line memory module (DIMM), a small outline DIMM(SO-DIMM), a non-volatile dual in-line memory module (NVDIMM), etc. Insome embodiments, the memory sub-system can be a hybrid memory/storagesub-system. In general, a host system can utilize a memory sub-systemthat includes one or more memory components. The host system can providedata to be stored at the memory sub-system and can request data to beretrieved from the memory sub-system.

The memory sub-system can include multiple memory components that canstore data from the host system. Each memory component can include adifferent type of media. Examples of media include, but are not limitedto, a cross-point array of non-volatile memory and flash based memorysuch as single-level cell (SLC) memory, triple-level cell (TLC) memory,and quad-level cell (QLC) memory. Different types of media can havedifferent data density. Data density corresponds to an amount of data(e.g., bits of data) that can be stored per memory cell of a memorycomponent. Using the example of a flash based memory, a quad-level cell(QLC) can store four bits of data while a single-level cell (SLC) canstore one bit of data. Accordingly, a memory component including QLCmemory cells will have a higher data density than a memory componentincluding SLC memory cells. A memory cell can be converted to adifferent type by storing a different number of bits of data at thememory cell. For example, a QLC memory cell can become an SLC memorycell if a single bit of data is written to the memory cell that waspreviously used to store four bits of data.

A conventional memory sub-system includes memory components having baddata blocks. A bad data block (hereinafter also referred to as “badblock”) is a data block (i.e., a group of one or more memory cells in amemory component) that cannot reliably store data. For example, a baddata block can refer to a data block that satisfies a failure conditionas described in further detail below. Due to non-uniformity andvariation in a manufacturing process, the conventional memory sub-systeminitially includes a small percentage of bad data blocks. In addition,good data blocks (i.e., data blocks that are not classified as a baddata block and that can initially reliably store data) can become baddata blocks as data blocks wear out during the lifetime of the memorysub-system. Accordingly, bad data blocks in the conventional memorysub-system have not been used to store data. Instead, the conventionalmemory sub-system can track the bad data blocks and avoid storing anydata at the bad data blocks. Therefore, the memory capacity of theconventional memory sub-system can decrease as more data blocks becomeunreliable and not used for data storage.

Aspects of the present disclosure address the above and otherdeficiencies by utilizing bad data blocks to store a specific number ofbits of data per memory cell of a bad data block. Although memory cellsof bad data blocks can be unreliable to store a large number of bits ofdata, the memory cells can still be used to reliably store a single bitof data. For example, the bad data block can be degraded over time andcannot reliably store multiple bits at the memory cell, but the bad datablock can still reliably store fewer bits (e.g., one bit) at the memorycells. Typically, an SLC or a memory cell written in an SLC mode has awider read margin that separates states of bits (i.e., bit values) thana reading margin of a QLC memory cell, or any other multi-level cells.The wider reading margin would result in a possibility of less error asthere is a larger separation between the states of bits as fewer bitsare stored at the SLC memory cell. For example, a memory cell storing asingle bit can include two states or bit values (e.g., a 0 or a 1) whilea memory cell storing four bits can include sixteen states or bit values(e.g., 0000 to 1111). The entire reading margin of a memory cell can beused to separate between the two states or bits when the memory cellincludes the two states or bit values. However, the same reading marginof the memory cell can be divided between the sixteen states or bitvalues when the memory cell is to store sixteen states or bit values.Thus, the reading margin between the states or bit values of an SLCmemory cell can be larger than the reading margin between the states orbit values of a QLC memory cell.

Therefore, even if the memory cell of bad data blocks may not bereliable to be used as a QLC memory cell, the memory cell can still beused as an SLC memory cell. In this way, the memory sub-system can stillutilize bad data blocks in addition to the good data blocks. Further,the bad data blocks can be used to store system data such as loginformation, maintenance information, and characteristics of the memorysub-system while the good data blocks can be used to store user data.

Advantages of the present disclosure include, but are not limited to, anincreased storage capacity of the memory sub-system as the bad datablocks can be used to store certain types of system data. Furthermore,since the system data would be stored and/or retrieved from the bad datablocks in an SLC mode, the performance of the memory sub-system can beimproved as the reading and writing of data to memory cells in the SLCmode can be faster when compared to using operations using a QLC mode(e.g., the default mode). FIG. 1 illustrates an example computingenvironment 100 that includes a memory sub-system 110 in accordance withsome embodiments of the present disclosure. The memory sub-system 110can include media, such as memory components 112A to 112N. The memorycomponents 112A to 112N can be volatile memory components, non-volatilememory components, or a combination of such. In some embodiments, thememory sub-system is a storage system. An example of a storage system isa SSD. In some embodiments, the memory sub-system 110 is a hybridmemory/storage sub-system. In general, the computing environment 100 caninclude a host system 120 that uses the memory sub-system 110. Forexample, the host system 120 can write data to the memory sub-system 110and read data from the memory sub-system 110.

The host system 120 can be a computing device such as a desktopcomputer, laptop computer, network server, mobile device, or suchcomputing device that includes a memory and a processing device. Thehost system 120 can include or be coupled to the memory sub-system 110so that the host system 120 can read data from or write data to thememory sub-system 110. The host system 120 can be coupled to the memorysub-system 110 via a physical host interface. As used herein, “coupledto” generally refers to a connection between components, which can be anindirect communicative connection or direct communicative connection(e.g., without intervening components), whether wired or wireless,including connections such as electrical, optical, magnetic, etc.Examples of a physical host interface include, but are not limited to, aserial advanced technology attachment (SATA) interface, a peripheralcomponent interconnect express (PCIe) interface, universal serial bus(USB) interface, Fibre Channel, Serial Attached SCSI (SAS), etc. Thephysical host interface can be used to transmit data between the hostsystem 120 and the memory sub-system 110. The host system 120 canfurther utilize an NVM Express (NVMe) interface to access the memorycomponents 112A to 112N when the memory sub-system 110 is coupled withthe host system 120 by the PCIe interface. The physical host interfacecan provide an interface for passing control, address, data, and othersignals between the memory sub-system 110 and the host system 120.

The memory components 112A to 112N can include any combination of thedifferent types of non-volatile memory components and/or volatile memorycomponents. An example of non-volatile memory components includes anegative-and (NAND) type flash memory. Each of the memory components112A to 112N can include one or more arrays of memory cells such assingle level cells (SLCs) or multi-level cells (MLCs) (e.g., triplelevel cells (TLCs) or quad-level cells (QLCs)). In some embodiments, aparticular memory component can include both an SLC portion and a MLCportion of memory cells. Each of the memory cells can store one or morebits of data (e.g., data blocks) used by the host system 120. The memorycells can be a part of bad data blocks or good data blocks. Althoughnon-volatile memory components such as NAND type flash memory aredescribed, the memory components 112A to 112N can be based on any othertype of memory such as a volatile memory. In some embodiments, thememory components 112A to 112N can be, but are not limited to, randomaccess memory (RAM), read-only memory (ROM), dynamic random accessmemory (DRAM), synchronous dynamic random access memory (SDRAM), phasechange memory (PCM), magneto random access memory (MRAM), negative-or(NOR) flash memory, electrically erasable programmable read-only memory(EEPROM), and a cross-point array of non-volatile memory cells. Across-point array of non-volatile memory can perform bit storage basedon a change of bulk resistance, in conjunction with a stackablecross-gridded data access array. Additionally, in contrast to manyflash-based memories, cross-point non-volatile memory can perform awrite in-place operation, where a non-volatile memory cell can beprogrammed without the non-volatile memory cell being previously erased.Furthermore, the memory cells of the memory components 112A to 112N canbe grouped as memory pages or data blocks that can refer to a unit ofthe memory component used to store data.

The memory system controller 115 (hereinafter referred to as“controller”) can communicate with the memory components 112A to 112N toperform operations such as reading data, writing data, or erasing dataat the memory components 112A to 112N and other such operations. Thecontroller 115 can include hardware such as one or more integratedcircuits and/or discrete components, a buffer memory, or a combinationthereof. The controller 115 can be a microcontroller, special purposelogic circuitry (e.g., a field programmable gate array (FPGA), anapplication specific integrated circuit (ASIC), etc.), or other suitableprocessor. The controller 115 can include a processor (processingdevice) 117 configured to execute instructions stored in local memory119. In the illustrated example, the local memory 119 of the controller115 includes an embedded memory configured to store instructions forperforming various processes, operations, logic flows, and routines thatcontrol operation of the memory sub-system 110, including handlingcommunications between the memory sub-system 110 and the host system120. In some embodiments, the local memory 119 can include memoryregisters storing memory pointers, fetched data, etc. The local memory119 can also include read-only memory (ROM) for storing micro-code.While the example memory sub-system 110 in FIG. 1 has been illustratedas including the controller 115, in another embodiment of the presentdisclosure, a memory sub-system 110 may not include a controller 115,and may instead rely upon external control (e.g., provided by anexternal host, or by a processor or controller separate from the memorysub-system).

In general, the controller 115 can receive commands or operations fromthe host system 120 and can convert the commands or operations intoinstructions or appropriate commands to achieve the desired access tothe memory components 112A to 112N. The controller 115 can beresponsible for other operations such as wear leveling operations,garbage collection operations, error detection and error-correcting code(ECC) operations, encryption operations, caching operations, and addresstranslations between a logical block address and a physical blockaddress that are associated with the memory components 112A to 112N. Thecontroller 115 can further include host interface circuitry tocommunicate with the host system 120 via the physical host interface.The host interface circuitry can convert the commands received from thehost system into command instructions to access the memory components112A to 112N as well as convert responses associated with the memorycomponents 112A to 112N into information for the host system 120.

The memory sub-system 110 can also include additional circuitry orcomponents that are not illustrated. In some embodiments, the memorysub-system 110 can include a cache or buffer (e.g., DRAM) and addresscircuitry (e.g., a row decoder and a column decoder) that can receive anaddress from the controller 115 and decode the address to access thememory components 112A to 112N.

The memory sub-system 110 includes a data block managing component 113that can be used to store data at a bad data block or good data blockbased on a type of data. In some embodiments, the controller 115includes at least a portion of the data block managing component 113.For example, the controller 115 can include a processor 117 (processingdevice) configured to execute instructions stored in local memory 119for performing the operations described herein. In some embodiments, thedata block managing component 113 is part of the host system 120, anapplication, or an operating system.

The data block managing component 113 can receive data to be stored inmemory components 112A to 112N of the memory sub-system 110. The datablock managing component 113 can, based on the type of data, determineto store the data to a bad data block or a good data block. The datablock managing component 113 can reference a data structure (e.g., atable) or information specifying locations of bad data blocks and/orgood data blocks to identify which data block to use. The data blockmanaging component 113 can also maintain the data structure orinformation specifying locations of bad data blocks and/or good datablocks over time as good data blocks become associated with a failurecondition and become bad data blocks. When storing data to a bad datablock, the data block managing component 113 can perform read or writeoperation in an SLC mode. Further details with regards to the operationsof the data block managing component 113 are described below.

FIG. 2A illustrates an example of determining whether to store data at abad data block in accordance with some embodiments of the presentdisclosure. The memory sub-system 200 includes the data block managingcomponent 113, information about data block pool 220, and a media 210.The data block pool 220 can be in a form of a data structure stored atthe local memory 119 of the memory sub-system 110 or the data blockmanaging component 113. In some embodiments, the data block pool 220 canbe stored as metadata in the media 210. The data block pool 220corresponds to a record or table for locations of data blocks that areclassified as bad data blocks or good data blocks. The data block pool220 can include information about a pool of good data blocks 224 and apool of bad data blocks 228. The record for the pool of good data blocks224 and bad data blocks 228 can be in a form of a list, a table, or anyother suitable data structure. The pool of bad data blocks 228 caninitially be provided from a manufacturer of the memory sub-system 110.For example, at an initial operating point of the memory sub-system 110,the pool of bad data blocks 228 can identify the data blocks of thememory sub-system 110 that are considered to be bad data blocks atmanufacturing of the memory sub-system 110. In some embodiments, thepool of bad data blocks 228 can be updated throughout the lifetime ofthe memory sub-system 110 by the data block managing component 113 asdescribed with respect to FIG. 2B below. The pool of good data blocks224 can be derived from the default information about the pool of baddata blocks 228. For example, if the data block managing component 113is only given the information about the pool of bad data blocks 228(e.g., at the initial operating point of the memory sub-system 110),then the data block managing component 113 can determine the pool ofgood data blocks 224 as data blocks that are complementary to the poolof bad data blocks 228. The pool of good data blocks 224 can be anyother data blocks not included in the pool of bad data blocks 228. Themedia 210 can be any media 112A to 112N connected with the data blockmanaging component 113 as illustrated in FIG. 1.

The data block managing component 113 can determine which data block(i.e., bad or good data block) to store the received data based on thetype of data. As illustrated, by flow 201, the data block managingcomponent 113 can receive system data of the memory sub-system 110. Thesystem data can correspond to any data generated by the memorysub-system 110. In some embodiments, the system data can be metadata ofuser data or information that is generated when user data is stored atthe memory sub-system 110. In response, the data block managingcomponent 113 can access the data block pool 220 to determine from thepool of bad data blocks 228 which bad data block (e.g., a data block“B”) is available for storing the system data. The data block managingcomponent 113 can store the received system data at data block B asillustrated by flow 205. The data block managing component 113 canfurther store the system data to the bad block B using an SLCprogramming operation (i.e., a programming operation involving a singlebit of data per memory cell). In another example, the data blockmanaging component 113 can receive user data of the host system 120 asrepresented by flow 202. The user data can correspond to data receivedfrom the host system 120. The data block managing component 113 cansimilarly access the data block pool 220 for information on the pool ofgood data blocks 224. The pool of good data blocks 224 can correspond toa map that indicates which data blocks of the media 210 are good datablocks. Once the data block managing component 113 determines which gooddata block (i.e., a data block “A”) is available, the data blockmanaging component 113, as shown by flow 206, can store the user data atthe data block A. The data block managing component 113 can use adefault programming operation, such as a QLC programming operation tostore data at the good data block. In some embodiments, the data blockmanaging component 113 can use any other programming operation such asan MLC or TLC programming operation. For example, the programmingoperation for the good data blocks can be any type of programmingoperation that writes more bits per memory cell than the programmingoperation that is used to store data at the memory cells of the bad datablocks. Accordingly, if the received data is system data, the data blockmanaging component 113 can determine to store the system data at a baddata block, the user data can be stored at a good data block. Thus, thedata block managing component 113 can improve the use of the media 210at a memory sub-system.

FIG. 2B illustrates an example of updating a pool of bad data blocks inaccordance with some embodiments of the present disclosure. Similar toFIG. 2A, the memory sub-system 200 includes the data block managingcomponent 113, the information about the data block pool 220, and themedia 210. As shown by flow 207, the data block managing component 113can detect a failure of a data block E of the media 210. For example,the data block managing component 113 can detect the failure when thedata block managing component 113 cannot retrieve data stored at thedata block E, or cannot write to data at the data block E. In someembodiments, the data block managing component 113 can detect a failureof the data block E when data read from the data block E includes anumber of errors that satisfies a threshold amount of errors. Forexample, the data block E can be considered to be associated with thefailure condition when the number of errors or the rate of errors fromdata stored at the data block E exceeds a threshold number or athreshold rate of errors. Such a number of errors or rate of errors canincrease when more memory cells of the data block E become degradedthroughout the lifetime of the memory sub-system 110. In someembodiments, such errors are associated with data stored using a QLCprogramming operation. Upon such failure, the data block managingcomponent 113 can regard the data block E as a bad data block.Accordingly, the data block managing component 113, per flow 208,updates the data block pool 220. As illustrated, the data block E whichwas previously a good data block is removed from the pool of good datablocks 224 and is added to the pool of bad data blocks 228. As such, thedata block managing component 113 can maintain the record of the datablock pool 220 whenever such a failure of a data block is detected. Inthis way, the most up-to-date information about the data block pool 220can be used to maximize the storage capacity of the memory sub-system110.

FIG. 3 is a flow diagram of an example method to store data at a baddata block of a memory sub-system 110 based on a type of data inaccordance with some embodiments of the present disclosure. The method300 can be performed by processing logic that can include hardware(e.g., processing device, circuitry, dedicated logic, programmablelogic, microcode, hardware of a device, integrated circuit, etc.),software (e.g., instructions run or executed on a processing device), ora combination thereof. In some embodiments, the method 300 is performedby the data block managing component 113 of FIG. 1. Although shown in aparticular sequence or order, unless otherwise specified, the order ofthe processes can be modified. Thus, the illustrated embodiments shouldbe understood only as examples, and the illustrated processes can beperformed in a different order, and some processes can be performed inparallel. Additionally, one or more processes can be omitted in variousembodiments. Thus, not all processes are required in every embodiment.Other process flows are possible.

At operation 310, the processing device determines a first group of datablocks of a memory sub-system that are associated with a failurecondition. The first group of data blocks can be referred to as a groupof bad data blocks. The failure condition can refer to a failureassociated with a memory cell with a particular number of bits (e.g.,QLC) or a failure related to a particular type of data (e.g., userdata). For example, the processing device can detect a failure conditionon a particular data block that stored user data and identify theparticular data block as a part of the first group of data blocks. Theprocessing device can detect the failure condition when a read or writeoperation on the particular data block that stored data under the QLCmode has failed. In some embodiments, the processing device can detectthe failure condition when the read or write operation for data blockstoring user data has failed.

For example, the processing device can determine that the particulardata block is associated with a failure of a read operation when theprocessing device cannot retrieve a particular user data stored on theparticular data block where the particular user data was stored usingthe QLC programming operation. As another example, the processing devicecan determine that a write operation on a particular data block to storeuser data by using the QLC programming operation has failed. Theprocessing device can then identify that the particular data block isassociated with the failure condition.

At operation 320, the processing device determines a second group ofdata of the memory sub-system that are not associated with the failurecondition. The second group of data blocks can be good data blocks ofthe memory sub-system 110 that are not associated with the failurecondition described above with respect to operation 310. For example,the processing device can identify a good data block when a readoperation or write operation on a data block is successful regardless ofthe number of bits or type of data the respective data block stores. Insome embodiments, in case the failure condition is associated with afailure of a read or write operation on a memory cell with a particularnumber of bits (e.g., QLC), then the processing device can identify as agood data block a data block with SLC, MLC, or TLC even though a read orwrite operation on the respective data block has failed, as well as adata block with QLC where a read or write operation was successful.

At operation 330, the processing device receives user data. The userdata can be any data received from the host system 120. For example, theprocessing device can receive data from the host system 120 that is tobe stored at the memory sub-system. The processing device, at operation340, generates system data of the memory sub-system 110. The system datacan correspond to any data generated by the memory sub-system 110 butnot the user data that is received from the host system 110 of thememory sub-system 110. For example, the system data can be any data thatidentifies characteristics of the memory sub-system 110 such astemperature of the memory sub-system 110, maintenance information, andlog information. In another example, the system data can be metadata forthe user data that is received from a host system 120 of the memorysub-system 110. Thus, the system data can be information generated bythe memory sub-system when user data is received to be stored by thememory sub-system 110. The system data can identify a characteristic ofthe memory sub-system when the respective user data is stored at thememory sub-system.

At operation 350, the processing device stores the system data at thefirst group of data blocks (i.e., bad data blocks) that is associatedwith the failure condition by using a first programming operation (e.g.,an SLC programming operation). Furthermore, at operation 360, theprocessing device stores the user data at the second group of datablocks (i.e., good data blocks) that is not associated with the failurecondition by using a second programming operation (e.g., a QLCprogramming operation) that is different than the first programmingoperation. The first programming operation can correspond to storing afirst number of bits (e.g., one) per memory cell of the first group ofdata blocks (i.e., bad data blocks) that is to store the system data.However, the second programming operation can correspond to programminga second number of bits (e.g., four) per memory cell of the second groupof data blocks (i.e., good data blocks) that is to store the user data.The second number of bits per memory cell can be larger than the firstnumber of bits per memory cell.

FIG. 4 is a flow diagram of an example method to manage a pool of baddata blocks of a memory sub-system 110 in accordance with someembodiments of the present disclosure. The method 400 can be performedby processing logic that can include hardware (e.g., processing device,circuitry, dedicated logic, programmable logic, microcode, hardware of adevice, integrated circuit, etc.), software (e.g., instructions run orexecuted on a processing device), or a combination thereof. In someembodiments, the method 400 is performed by the data block managingcomponent 113 of FIG. 1. Although shown in a particular sequence ororder, unless otherwise specified, the order of the processes can bemodified. Thus, the illustrated embodiments should be understood only asexamples, and the illustrated processes can be performed in a differentorder, and some processes can be performed in parallel. Additionally,one or more processes can be omitted in various embodiments. Thus, notall processes are required in every embodiment. Other process flows arepossible.

At operation 410, the processing device determines a first pool of datablocks (e.g., bad data blocks) of a memory sub-system 110. Uponmanufacturing, the memory sub-system 110 can initially contain bad datablocks. Accordingly, information about locations of bad data blocks canbe provided by the manufacturer and the processing device can accesssuch information. On the other hand, bad data blocks can develop duringthe lifetime of the memory sub-system 110. In any case, a record of baddata blocks can be maintained by the processing device. As describedabove with respect to operation 350, data blocks of the first pool(i.e., pool of bad data blocks) are associated with storing data at afirst number of bits (e.g., single) per memory cell of each data blockof the first pool.

The processing device, at operation 420, determines a second pool ofdata blocks (i.e., good data blocks) of the memory sub-system 110. Theprocessing device can access a record of bad data blocks and/or gooddata blocks to determine which group of data blocks are good datablocks. Data blocks of the second pool (i.e., pool of good data blocks)are associated with storing data at a second number of bits (e.g., four)per memory cell that is larger than the first number of bits (e.g.,single) per memory cell as described above with respect to operation360.

At operation 430, the processing device detects a failure associatedwith a particular data block of the second pool of data blocks (i.e.,good data blocks). The processing device can detect the failure asdescribed above with respect to operation 310 of FIG. 3. For example,the processing device can determine that a particular data block isassociated with a failure condition when the processing device cannotretrieve stored data from or write data to the particular data blockwhen using the QLC operation.

In response, the processing device, at operation 440, removes theparticular data block from the second pool of data blocks (i.e., gooddata blocks) and adds the particular data block to the first pool ofdata blocks (i.e., bad data blocks). As such, the processing device canupdate the bad block data location information. The processing devicecan repeat operations 430 and 440 on a periodic basis or when triggeredby a specific condition such as upon receiving system data from the hostsystem 120. The processing device can further erase data stored at theparticular data block from the second pool of data blocks (i.e., gooddata blocks) before adding the particular data block to the first poolof data blocks (i.e., bad data blocks). After performing the operation440, the processing device can proceed with operations of FIG. 3 tostore user data from the host system 120 to good data blocks and systemdata of the memory sub-system 110 to bad data blocks using the SLCprogramming operation.

After the first and/or second pool of data blocks have been updated, theprocessing device can attempt to perform the operation associated withthe failure detected at operation 430. In case of a write operation, theprocessing device can look up the record of bad data blocks and/or gooddata blocks and determine a good data block to store data. On the otherhand, in case a read operation has failed, the processing device canproceed to perform a data rebuild operation in order to recover datastored at the particular data block associated with the failure. Forexample, the data can be reconstructed based on a combination of otherdata and corresponding parity data.

FIG. 5 illustrates an example machine of a computer system 500 withinwhich a set of instructions, for causing the machine to perform any oneor more of the methodologies discussed herein, can be executed. In someembodiments, the computer system 500 can correspond to a host system(e.g., the host system 120 of FIG. 1) that includes, is coupled to, orutilizes a memory sub-system (e.g., the memory sub-system 110 of FIG. 1)or can be used to perform the operations of a controller (e.g., toexecute an operating system to perform operations corresponding to thedata block managing component 113 of FIG. 1). In alternativeembodiments, the machine can be connected (e.g., networked) to othermachines in a LAN, an intranet, an extranet, and/or the Internet. Themachine can operate in the capacity of a server or a client machine inclient-server network environment, as a peer machine in a peer-to-peer(or distributed) network environment, or as a server or a client machinein a cloud computing infrastructure or environment.

The machine can be a personal computer (PC), a tablet PC, a set-top box(STB), a Personal Digital Assistant (PDA), a cellular telephone, a webappliance, a server, a network router, a switch or bridge, or anymachine capable of executing a set of instructions (sequential orotherwise) that specify actions to be taken by that machine. Further,while a single machine is illustrated, the term “machine” shall also betaken to include any collection of machines that individually or jointlyexecute a set (or multiple sets) of instructions to perform any one ormore of the methodologies discussed herein.

The example computer system 500 includes a processing device 502, a mainmemory 504 (e.g., read-only memory (ROM), flash memory, dynamic randomaccess memory (DRAM) such as synchronous DRAM (SDRAM) or Rambus DRAM(RDRAM), etc.), a static memory 506 (e.g., flash memory, static randomaccess memory (SRAM), etc.), and a data storage system 518, whichcommunicate with each other via a bus 530.

Processing device 502 represents one or more general-purpose processingdevices such as a microprocessor, a central processing unit, or thelike. More particularly, the processing device can be a complexinstruction set computing (CISC) microprocessor, reduced instruction setcomputing (RISC) microprocessor, very long instruction word (VLIW)microprocessor, or a processor implementing other instruction sets, orprocessors implementing a combination of instruction sets. Processingdevice 502 can also be one or more special-purpose processing devicessuch as an application specific integrated circuit (ASIC), a fieldprogrammable gate array (FPGA), a digital signal processor (DSP),network processor, or the like. The processing device 502 is configuredto execute instructions 526 for performing the operations and stepsdiscussed herein. The computer system 500 can further include a networkinterface device 508 to communicate over the network 520.

The data storage system 518 can include a machine-readable storagemedium 524 (also known as a computer-readable medium) on which is storedone or more sets of instructions 526 or software embodying any one ormore of the methodologies or functions described herein. Theinstructions 526 can also reside, completely or at least partially,within the main memory 504 and/or within the processing device 502during execution thereof by the computer system 500, the main memory 504and the processing device 502 also constituting machine-readable storagemedia. The machine-readable storage medium 524, data storage system 518,and/or main memory 504 can correspond to the memory sub-system 110 ofFIG. 1.

In one embodiment, the instructions 526 include instructions toimplement functionality corresponding to a data block managing component(e.g., the data block managing component 113 of FIG. 1). While themachine-readable storage medium 524 is shown in an example embodiment tobe a single medium, the term “machine-readable storage medium” should betaken to include a single medium or multiple media that store the one ormore sets of instructions. The term “machine-readable storage medium”shall also be taken to include any medium that is capable of storing orencoding a set of instructions for execution by the machine and thatcause the machine to perform any one or more of the methodologies of thepresent disclosure. The term “machine-readable storage medium” shallaccordingly be taken to include, but not be limited to, solid-statememories, optical media, and magnetic media.

Some portions of the preceding detailed descriptions have been presentedin terms of algorithms and symbolic representations of operations ondata bits within a computer memory. These algorithmic descriptions andrepresentations are the ways used by those skilled in the dataprocessing arts to most effectively convey the substance of their workto others skilled in the art. An algorithm is here, and generally,conceived to be a self-consistent sequence of operations leading to adesired result. The operations are those requiring physicalmanipulations of physical quantities. Usually, though not necessarily,these quantities take the form of electrical or magnetic signals capableof being stored, combined, compared, and otherwise manipulated. It hasproven convenient at times, principally for reasons of common usage, torefer to these signals as bits, values, elements, symbols, characters,terms, numbers, or the like.

It should be borne in mind, however, that all of these and similar termsare to be associated with the appropriate physical quantities and aremerely convenient labels applied to these quantities. The presentdisclosure can refer to the action and processes of a computer system,or similar electronic computing device, that manipulates and transformsdata represented as physical (electronic) quantities within the computersystem's registers and memories into other data similarly represented asphysical quantities within the computer system memories or registers orother such information storage systems.

The present disclosure also relates to an apparatus for performing theoperations herein. This apparatus can be specially constructed for theintended purposes, or it can include a general purpose computerselectively activated or reconfigured by a computer program stored inthe computer. Such a computer program can be stored in a computerreadable storage medium, such as, but not limited to, any type of diskincluding floppy disks, optical disks, CD-ROMs, and magnetic-opticaldisks, read-only memories (ROMs), random access memories (RAMs), EPROMs,EEPROMs, magnetic or optical cards, or any type of media suitable forstoring electronic instructions, each coupled to a computer system bus.

The algorithms and displays presented herein are not inherently relatedto any particular computer or other apparatus. Various general purposesystems can be used with programs in accordance with the teachingsherein, or it can prove convenient to construct a more specializedapparatus to perform the method. The structure for a variety of thesesystems will appear as set forth in the description below. In addition,the present disclosure is not described with reference to any particularprogramming language. It will be appreciated that a variety ofprogramming languages can be used to implement the teachings of thedisclosure as described herein.

The present disclosure can be provided as a computer program product, orsoftware, that can include a machine-readable medium having storedthereon instructions, which can be used to program a computer system (orother electronic devices) to perform a process according to the presentdisclosure. A machine-readable medium includes any mechanism for storinginformation in a form readable by a machine (e.g., a computer). In someembodiments, a machine-readable (e.g., computer-readable) mediumincludes a machine (e.g., a computer) readable storage medium such as aread only memory (“ROM”), random access memory (“RAM”), magnetic diskstorage media, optical storage media, flash memory components, etc.

In the foregoing specification, embodiments of the disclosure have beendescribed with reference to specific example embodiments thereof. Itwill be evident that various modifications can be made thereto withoutdeparting from the broader spirit and scope of embodiments of thedisclosure as set forth in the following claims. The specification anddrawings are, accordingly, to be regarded in an illustrative senserather than a restrictive sense.

What is claimed is:
 1. A system comprising: a memory device; and aprocessing device, operatively coupled with the memory device, toperform operations comprising: determining a first pool of data blocksof the memory device, wherein data blocks of the first pool areassociated with storing data at a first number of bits per memory cell;determining a second pool of data blocks of the memory device, whereindata blocks of the second pool are associated with storing data at asecond number of bits per memory cell that is larger than the firstnumber of bits per memory cell; detecting a failure associated with aparticular data block of the second pool of data blocks; and in responseto detecting the failure associated with the particular data block,removing the particular data block from the second pool of data blocksand adding the particular data block to the first pool of data blocks.2. The system of claim 1, wherein detecting the failure associated withthe particular data block further comprises: determining that readingthe particular data block at the second number of bits per memory cellhas failed to retrieve a stored data at the particular data block. 3.The system of claim 1, wherein detecting the failure associated with theparticular data block further comprises: determining that writing datato the particular data block at the second number of bits per memorycell has failed.
 4. The system of claim 1, wherein removing theparticular data block from the second pool of data blocks and adding theparticular data block to the first pool of data blocks further comprise:erasing data stored at the particular data block from the second pool ofdata blocks; and adding the particular data block to the first pool ofdata blocks in response to erasing the data.
 5. The system of claim 1,wherein the processing device to perform operations further comprising:receiving user data; generating system data of a memory sub-systemassociated with the memory device; storing the user data to a data blockfrom the second pool of data blocks at the second number of bits permemory cell; and storing the system data to a data block from the firstpool of data blocks at the first number of bits per memory cell.
 6. Thesystem of claim 5, wherein storing the system data to the data blockfrom the first pool of data blocks at the second number of bits permemory cell further comprises storing the system data at a single-levelcell (SLC) mode, and wherein storing the user data to the data blockfrom the second pool of data blocks at the second number of bits permemory cell further comprises storing the user data by using aprogramming operation that stores a plurality of bits per each memorycell.
 7. The system of claim 5, wherein the system data corresponds to acharacteristic of the memory sub-system at a time when the user data isstored at the memory sub-system.
 8. A method comprising: determining afirst pool of data blocks of the memory device, wherein data blocks ofthe first pool are associated with storing data at a first number ofbits per memory cell; determining a second pool of data blocks of thememory device, wherein data blocks of the second pool are associatedwith storing data at a second number of bits per memory cell that islarger than the first number of bits per memory cell; detecting afailure associated with a particular data block of the second pool ofdata blocks; and in response to detecting the failure associated withthe particular data block, removing the particular data block from thesecond pool of data blocks and adding the particular data block to thefirst pool of data blocks.
 9. The method of claim 8, wherein detectingthe failure associated with the particular data block further comprises:determining that reading the particular data block at the second numberof bits per memory cell has failed to retrieve a stored data at theparticular data block.
 10. The method of claim 8, wherein detecting thefailure associated with the particular data block further comprises:determining that writing data to the particular data block at the secondnumber of bits per memory cell has failed.
 11. The method of claim 8,wherein removing the particular data block from the second pool of datablocks and adding the particular data block to the first pool of datablocks further comprise: erasing data stored at the particular datablock from the second pool of data blocks; and adding the particulardata block to the first pool of data blocks in response to erasing thedata.
 12. The method of claim 8 further comprising: receiving user data;generating system data of a memory sub-system associated with the memorydevice; storing the user data to a data block from the second pool ofdata blocks at the second number of bits per memory cell; and storingthe system data to a data block from the first pool of data blocks atthe first number of bits per memory cell.
 13. The method of claim 12,wherein storing the system data to the data block from the first pool ofdata blocks at the second number of bits per memory cell furthercomprises storing the system data at a single-level cell (SLC) mode, andwherein storing the user data to the data block from the second pool ofdata blocks at the second number of bits per memory cell furthercomprises storing the user data by using a programming operation thatstores a plurality of bits per each memory cell.
 14. The method of claim12, wherein the system data corresponds to a characteristic of thememory sub-system at a time when the user data is stored at the memorysub-system.
 15. A non-transitory computer-readable storage mediumcomprising instructions that, when executed by a processing device,cause the processing device to perform operations comprising:determining a first pool of data blocks of the memory device, whereindata blocks of the first pool are associated with storing data at afirst number of bits per memory cell; determining a second pool of datablocks of the memory device, wherein data blocks of the second pool areassociated with storing data at a second number of bits per memory cellthat is larger than the first number of bits per memory cell; detectinga failure associated with a particular data block of the second pool ofdata blocks; and in response to detecting the failure associated withthe particular data block, removing the particular data block from thesecond pool of data blocks and adding the particular data block to thefirst pool of data blocks.
 16. The non-transitory computer-readablestorage medium of claim 15, wherein detecting the failure associatedwith the particular data block further comprises: determining thatreading the particular data block at the second number of bits permemory cell has failed to retrieve a stored data at the particular datablock.
 17. The non-transitory computer-readable storage medium of claim15, wherein detecting the failure associated with the particular datablock further comprises: determining that writing data to the particulardata block at the second number of bits per memory cell has failed. 18.The non-transitory computer-readable storage medium of claim 15, whereinremoving the particular data block from the second pool of data blocksand to add the particular data block to the first pool of data blocksfurther comprises: erasing data stored at the particular data block fromthe second pool of data blocks; and adding the particular data block tothe first pool of data blocks in response to erasing the data.
 19. Thenon-transitory computer-readable storage medium of claim 15, wherein theprocessing device is to perform operations further comprising:generating system data of a memory sub-system associated with the memorydevice; storing the user data to a data block from the second pool ofdata blocks at the second number of bits per memory cell; and storingthe system data to a data block from the first pool of data blocks atthe first number of bits per memory cell.
 20. The non-transitorycomputer-readable storage medium of claim 19, wherein the system datacorresponds to a characteristic of the memory sub-system at a time whenthe user data is stored at the memory sub-system.